// 使用统一配置入口模式导入所需模块
const pathResolver = require('../../../config/path_resolver.js');

// 从配置文件导入辅助工具
const { pageHelper, cloudHelper } = require('../../../config/project_helpers_config');
const { errorHelper, timeHelper, cacheHelper } = require('../../../config/simple_helpers_config');
const { validate } = require('../../../config/simple_helpers_config');
const { dateHelper, statusHelper } = require('../../../config/project_helpers_config');

// 从配置文件导入库和业务逻辑
const { _ } = require('../../../config/libs_config');
const { ProjectBiz, PlmBiz } = require('../../../config/biz_config.js');
const { ProjectModel } = require('../../../config/models_config.js');

// 使用统一的store配置
const { createStoreBindings, plmProjectStore, userStore } = require('../../../config/store_config.js');

// 导入日期格式化库
const dayjs = require('../../../config/libs_config').dayjs;

// 导入角色和状态机配置
const ResearchRoleConfig = require('../../../config/research_role_config.js');
const ResearchStateMachine = require('../../../config/research_state_machine.js');

// 使用本地project_store替代projectListStore
import '../../../store/project_store';

const { logEvent } = require('../../../helpers/log_helper.js');
const { getNetworkStatus, listenNetworkStatus } = require('../../../helpers/network_helper.js');

Component({
	options: {
		addGlobalClass: true
	},

	/**
	 * 页面的初始数据
	 */
	data: {
		title: '项目列表',
		
		// 列表数据
		dataList: [],
		projects: [],
		
		// 加载状态
		isLoad: false,
		isLoading: false,
		loadingError: false,
		isAllLoaded: false,
		
		// 页面状态
		isFilterOpen: false,
		isStatsOpen: false,
		isQuickAccessOpen: true,
		
		page: 1,
		pageSize: 20,
		pagination: { page: 1, size: 20, total: 0, hasMore: true },

		search: '',
		
		cate: 0,
		cateOptions: [
			{ value: '0', label: '全部类型' },
			{ value: '磁编', label: '磁编' },
			{ value: '霍尔', label: '霍尔' },
			{ value: '吸尘器', label: '吸尘器' },
			{ value: '风机', label: '风机' },
			{ value: '水泵', label: '水泵' },
			{ value: '其他', label: '其他' }
		],
		
		status: 0,
		statusOptions: [
			{ value: 0, label: '全部状态' },
			{ value: 1, label: '待立项' },
			{ value: 2, label: '已立项' },
			{ value: 3, label: '设计中' },
			{ value: 4, label: '开发中' },
			{ value: 5, label: '测试中' },
			{ value: 6, label: '已完成' },
			{ value: 99, label: '已取消' }
		],
		
		devManager: 0,
		devManagerOptions: [
			{ value: 0, label: '全部研发负责人' },
			{ value: 1, label: '张三' },
			{ value: 2, label: '李四' },
			{ value: 3, label: '未分配' }
		],
		
		bizManager: 0,
		bizManagerOptions: [
			{ value: 0, label: '全部业务负责人' },
			{ value: 1, label: '王五' },
			{ value: 2, label: '赵六' },
			{ value: 3, label: '未分配' }
		],

		userRole: '',
		showNewBtn: false,
		
		quickAccessList: [],

		isLoadingPage: false,
		noMore: false,
		
		selectedStatus: 'all',
		sortOptions: [
			{ text: '最近创建', value: 'recent', checked: true },
			{ text: '截止日期', value: 'deadline', checked: false },
			{ text: '优先级', value: 'priority', checked: false },
		],
		selectedSort: 'recent',
	},

	lifetimes: {
		created() {
			console.log('项目列表组件 created');
		},
		
		attached() {
			console.log('项目列表组件 attached');
			
			// 创建MobX绑定
			this.storeBindings = createStoreBindings(this, {
				store: plmProjectStore,
				fields: [
					'loading',
					'projects',
					'quickAccessList',
					'filter',
					'pagination',
					'filteredProjects',
					'projectCount'
				],
				actions: [
					'loadProjects',
					'setFilter',
					'loadQuickAccessList',
					'addToQuickAccess',
					'removeFromQuickAccess',
					'reset'
				]
			});
			
			// 确保store中有初始值，避免undefined错误
			plmProjectStore.projects = plmProjectStore.projects || [];
			plmProjectStore.quickAccessList = plmProjectStore.quickAccessList || [];
			plmProjectStore.filter = plmProjectStore.filter || {};
			plmProjectStore.filteredProjects = plmProjectStore.filteredProjects || [];
			plmProjectStore.projectCount = plmProjectStore.projectCount || 0;
			
			// 确保页面数据初始值正确
			this.setData({
				loading: true,
				dataList: [],
				filteredProjects: []
			});
			
			// 加载用户角色
			this._loadUserRole();
			
			// 强制从云端加载项目列表
			console.log('[项目列表] 强制从云端加载数据');
			this._forceRefreshList(true); // 直接调用_forceRefreshList而不是loadProjects
			
			// 获取最近访问的项目
			this._getRecentProjects();
		},
		
		detached() {
			console.log('项目列表组件 detached');
			
			// 清理MobX绑定
			this.storeBindings.destroyStoreBindings();
		}
	},
	
	pageLifetimes: {
		show() {
			console.log('项目列表页面显示');
			
			// 如果已经加载过，就刷新最近访问的项目
			if (this.data.isLoad) {
				// 先获取最新的项目列表数据
				this._getRecentProjects();
				// 强制更新一次快速访问标记
				setTimeout(() => {
					this._loadQuickAccessList();
					this._updateQuickAccessMarks();
				}, 100);
			} else {
				// 首次显示时直接使用Store中的数据
				this._loadFromStore();
			}
		},
		
		hide() {
			console.log('项目列表页面隐藏');
		}
	},

	methods: {
		/**
		 * 加载用户角色
		 */
		async _loadUserRole() {
			// 获取当前用户角色
			const userInfo = userStore.user || {};
			const userRole = userInfo.role || '';
			
			this.setData({
				userRole,
				showNewBtn: ResearchRoleConfig.hasEventPermission(userRole, ResearchStateMachine.EVENTS.CREATE_PROJECT)
			});
		},

		/**
		 * 加载项目列表
		 */
		_loadList: async function(forceRefresh = false, useCloudData = false) {
			// 防止重复加载
			if (this.data.isLoading) return;
			
			// 设置加载状态
			this.setData({
				isLoading: true,
				loadingError: false
			});
			
			// 准备参数
			const params = {
				page: this.data.page,
				size: this.data.pageSize,
				search: this.data.search || '',
				status: this.data.status || 'all',
				cate: this.data.cate || 0,
				sort: this.data.selectedSort || 'recent'
			};
			
			// 处理返回的数据结果（共享函数）
			const handleDataResult = (result) => {
				// 详细记录收到的数据结构
				console.log('收到的原始数据结果:', result);
				
				// 获取项目列表和总数
				let projectList = [];
				let total = 0;
				
				// 更强大的数据提取逻辑
				if (result) {
					// 标准云函数返回格式检查 {code:200, msg:"ok", data:{list:[], total:0}}
					if (result.code === 200 && result.data && result.data.list) {
						projectList = result.data.list;
						total = result.data.total || projectList.length;
						console.log('从标准云函数返回格式提取数据，长度:', projectList.length);
					}
					// 直接检查list属性（模拟服务通常返回这种格式）
					else if (result.list && Array.isArray(result.list)) {
						projectList = result.list;
						total = result.total || projectList.length;
						console.log('从result.list提取数据，长度:', projectList.length);
					}
					// 云函数可能返回包装在data中的数据
					else if (result.data) {
						if (Array.isArray(result.data)) {
							projectList = result.data;
							total = projectList.length;
							console.log('从result.data数组提取数据，长度:', projectList.length);
						}
						else if (result.data.list && Array.isArray(result.data.list)) {
							projectList = result.data.list;
							total = result.data.total || projectList.length;
							console.log('从result.data.list提取数据，长度:', projectList.length);
						}
					}
					// 直接是数组的情况
					else if (Array.isArray(result)) {
						projectList = result;
						total = result.length;
						console.log('直接提取数组数据，长度:', projectList.length);
					}
					
					// 调试输出提取到的数据样例
					if (projectList && projectList.length > 0) {
						console.log('成功提取的数据示例:', JSON.stringify(projectList[0]));
					}
				}
				
				// 如果没有获取到数据，返回空数组
				if (!projectList || projectList.length === 0) {
					console.log('未获取到项目数据，返回空数组');
					projectList = []; // 返回空数组，不再使用备用数据
					total = 0;
				}
				
				console.log('最终使用的项目数据，数量:', projectList.length);
				
				// 格式化项目数据
				const formattedList = this._formatProjectList(projectList);
				
				// 更新界面
				this.setData({
					dataList: formattedList,
					pagination: {
						page: params.page,
						size: params.size,
						total: total,
						hasMore: (params.page * params.size) < total
					},
					isLoad: true,
					isLoading: false,
					loadingError: false
				});
				
				// 手动设置MobX store中的相关字段
				plmProjectStore.projects = formattedList;
				plmProjectStore.filteredProjects = formattedList;
				plmProjectStore.projectCount = total;
			};
			
			// 优先使用cloud_helper获取数据
			try {
				console.log('使用cloud_helper获取项目列表数据...');
				const options = {
					title: '加载中...',
					hasLoading: true,
					useOfflineData: !useCloudData,
					forceCloud: useCloudData
				};
				
				console.log('[项目列表] 请求选项:', options);
				
				const result = await cloudHelper.callCloudData('mcloud', {
					route: 'project_list',
					page: this.data.page,
					size: this.data.pageSize,
					search: this.data.search || '',
					status: this.data.status || 'all',
					cate: this.data.cate || 0,
					sort: this.data.selectedSort || 'recent',
					PID: 'plm' // 显式指定PID为plm
				}, options);
				
				// 确保结果是有效的
				if (!result) {
					console.warn('cloud_helper返回的数据为空，将尝试备用方法');
					throw new Error('返回数据为空');
				}
				
				console.log('cloud_helper数据加载成功，共', 
					Array.isArray(result.list) ? result.list.length : '未知数量', '条记录');
				
				// 处理返回数据
				handleDataResult(result);
				
				return;
			} catch (error) {
				console.error('使用cloud_helper获取数据失败:', error);
				
				// 如果获取数据失败，显示空列表
				handleDataResult(null);
				
				// 显示轻微错误提示
				wx.showToast({
					title: '数据加载失败',
					icon: 'none',
					duration: 2000
				});
			}
		},
		
		/**
		 * 格式化项目列表数据
		 */
		_formatProjectList(projectList) {
			// 添加更多调试信息
			console.log('[项目列表] 格式化项目数据，输入:', projectList);
			
			if (!projectList) {
				console.warn('[项目列表] _formatProjectList接收到null或undefined，返回空数组');
				return [];
			}
			
			if (!Array.isArray(projectList)) {
				console.warn('[项目列表] _formatProjectList接收到的不是数组，返回空数组');
				return [];
			}
			
			if (projectList.length === 0) {
				console.warn('[项目列表] _formatProjectList接收到空数组');
				return [];
			}
			
			console.log('[项目列表] 格式化前第一条项目样本:', projectList[0]);
			
			// 获取当前快速访问ID列表
			const quickAccessIds = this._getQuickAccessIds();
			console.log('[项目列表] 格式化时获取到快速访问ID列表, 数量:', quickAccessIds.length);
			
			const formattedList = projectList.map((item, index) => {
				// 确保item是有效对象
				if (!item) return null;
				
				// 生成唯一的渲染key
				const renderKey = `${item._id || 'unknown'}-${index}`;
				
				// 计算截止日期状态
				let deadlineStatus = '';
				let deadlineMessage = '';
				if (item.deadline) {
					const now = Math.floor(Date.now() / 1000);
					const deadlineDays = Math.floor((item.deadline - now) / 86400);
					
					if (deadlineDays < 0) {
						deadlineStatus = 'overdue';
						deadlineMessage = `已逾期${Math.abs(deadlineDays)}天`;
					} else if (deadlineDays < 7) {
						deadlineStatus = 'warning';
						deadlineMessage = `剩余${deadlineDays}天`;
					} else {
						deadlineStatus = 'normal';
						deadlineMessage = `剩余${deadlineDays}天`;
					}
				}
				
				// 开发状态样式
				let developmentStatusClass = 'status-default';
				if (item.developmentStatus) {
					if (item.developmentStatus.includes('完成')) {
						developmentStatusClass = 'status-complete';
					} else if (item.developmentStatus.includes('测试')) {
						developmentStatusClass = 'status-testing';
					} else if (item.developmentStatus.includes('开发')) {
						developmentStatusClass = 'status-developing';
					} else if (item.developmentStatus.includes('设计')) {
						developmentStatusClass = 'status-designing';
					} else if (item.developmentStatus.includes('暂停') || item.developmentStatus.includes('取消')) {
						developmentStatusClass = 'status-paused';
					}
				}
				
				// 状态颜色
				let statusColor = '#2196F3'; // 默认蓝色
				if (item.status === 1) statusColor = '#FF9800'; // 待立项 - 橙色
				else if (item.status === 2) statusColor = '#4CAF50'; // 已立项 - 绿色
				else if (item.status === 3) statusColor = '#9C27B0'; // 设计中 - 紫色
				else if (item.status === 4) statusColor = '#03A9F4'; // 开发中 - 浅蓝
				else if (item.status === 5) statusColor = '#FF5722'; // 测试中 - 深橙
				else if (item.status === 6) statusColor = '#4CAF50'; // 已完成 - 绿色
				else if (item.status === 99) statusColor = '#9E9E9E'; // 已取消 - 灰色
				
				// 确保进度在0-100之间
				const completionPercentage = Math.min(100, Math.max(0, item.progress || 0));
				
				// 检查是否在快速访问列表中 - 直接使用ID列表判断，更可靠
				const isInQuickAccess = quickAccessIds.includes(item._id);
				
				return {
					...item,
					renderKey,
					isExpanded: false, // 默认折叠
					isInQuickAccess,
					deadlineStatus,
					deadlineMessage,
					developmentStatusClass,
					statusColor,
					completionPercentage
				};
			}).filter(item => item !== null); // 过滤掉无效的项目
			
			console.log('[项目列表] 格式化后数据长度:', formattedList.length);
			if (formattedList.length > 0) {
				console.log('[项目列表] 格式化后第一条项目样本:', formattedList[0]);
			}
			
			return formattedList;
		},
		
		/**
		 * 获取快速访问项目ID列表
		 */
		_getQuickAccessIds() {
			const recentProjects = wx.getStorageSync('recentProjects') || [];
			return recentProjects.map(item => item._id);
		},
		
		/**
		 * 从缓存或备用数据加载
		 */
		_loadFromCacheOrBackup: function(params) {
			console.log('尝试使用备选方法加载项目列表');
			
			// 首先尝试从缓存读取
			const cacheKey = `plm_project_list_cache`;
			
			let cacheData = cacheHelper.get(cacheKey);
			if (cacheData) {
				console.log('使用缓存数据显示项目列表');
				
				// 格式化项目数据
				const formattedList = this._formatProjectList(cacheData.list || []);
				
				// 使用缓存数据更新界面
				this.setData({
					dataList: formattedList,
					pagination: {
						page: params.page,
						size: params.size,
						total: cacheData.total || 0,
						hasMore: false  // 禁用加载更多
					},
					isLoad: true,
					isAllLoaded: true,  // 禁用加载更多
					isLoading: false,
					loadingError: false  // 清除错误状态
				});
				
				return;  // 使用缓存成功，提前返回
			}
			
			// 不再加载模拟数据，直接显示空列表
			this.setData({
				dataList: [],
				filteredProjects: [],
				pagination: {
					page: params.page,
					size: params.size,
					total: 0,
					hasMore: false
				},
				isLoad: true,
				isAllLoaded: true,
				isLoading: false,
				loadingError: false
			});
			
			// 清空快速访问列表，因为没有项目数据
			wx.setStorageSync('recentProjects', []);
			this.setData({
				quickAccessList: []
			});
		},
		
		/**
		 * 强制刷新列表
		 */
		_forceRefreshList: async function(useCloudData = false) {
			console.log('[项目列表] 强制刷新项目列表', useCloudData ? '(使用云端数据)' : '');
			
			// 重置页面参数
			this.setData({
				page: 1,
				isAllLoaded: false,
				isLoading: true
			});
			
			// 确保使用云端数据
			const options = {
				forceCloud: useCloudData === true, // 确保是布尔值true
				useOfflineData: false // 不使用离线数据
			};
			
			console.log('[项目列表] 强制刷新选项:', options);
			
			try {
				const result = await cloudHelper.callCloudData('mcloud', {
					route: 'project_list',
					page: this.data.page,
					size: this.data.pageSize,
					search: this.data.search || '',
					status: this.data.status || 'all',
					cate: this.data.cate || 0,
					sort: this.data.selectedSort || 'recent',
					PID: 'plm' // 显式指定PID为plm
				}, options);
				
				console.log('[项目列表] 强制刷新返回结果:', result);
				
				// 提取项目列表
				let projectList = [];
				if (result && result.data && result.data.list) {
					projectList = result.data.list;
					console.log('[项目列表] 成功获取云端数据，条数:', projectList.length);
				} else {
					console.error('[项目列表] 云端返回数据格式不正确:', result);
				}
				
				// 格式化项目数据
				const formattedList = this._formatProjectList(projectList);
				console.log('[项目列表] 格式化后数据项数:', formattedList.length);
				
				// 更新页面数据
				console.log('[项目列表] 更新页面数据');
				this.setData({
					dataList: formattedList,
					filteredProjects: formattedList,  // 同步更新filteredProjects
					isLoad: true,
					isLoading: false,
					loading: false  // 确保loading状态被正确设置为false
				});
				
				// 显式输出当前dataList状态
				console.log('[项目列表] 页面数据dataList现在有 ' + this.data.dataList.length + ' 条记录');
				console.log('[项目列表] 页面数据filteredProjects现在有 ' + this.data.filteredProjects.length + ' 条记录');
				
				// 更新Store中的数据
				if (projectList.length > 0) {
					console.log('[项目列表] 更新Store中的数据');
					plmProjectStore.projectList = projectList;
					plmProjectStore.projects = projectList;
					plmProjectStore.filteredProjects = projectList;
					plmProjectStore.projectCount = projectList.length;
				}
				
				// 加载快速访问列表并更新标记
				await this._loadQuickAccessList();
				
				// 强制进行一次额外的标记更新，确保标记正确
				setTimeout(() => {
					this._updateQuickAccessMarks();
				}, 100);
				
				// 尝试主动触发界面更新
				this.setData({
					dataList: [...formattedList],
					filteredProjects: [...formattedList]  // 同步更新filteredProjects
				});
				
				console.log('[项目列表] 完成刷新');
				
			} catch (err) {
				console.error('[项目列表] 强制刷新失败:', err);
				this.setData({
					isLoading: false,
					loadingError: true
				});
				
				// 失败时回退到普通加载
				await this._loadList(true, useCloudData);
			}
		},
		
		/**
		 * 加载快速访问列表
		 */
		_loadQuickAccessList: async function() {
			try {
				console.log('[项目列表] 加载快速访问列表开始');
				
				// 获取最近访问的项目
				const recentProjects = wx.getStorageSync('recentProjects') || [];
				console.log('[项目列表] 从Storage获取到快速访问项目数量:', recentProjects.length);
				
				// 获取当前项目列表的ID集合
				const projectIds = this.data.dataList.map(item => item._id);
				
				// 过滤快速访问列表，只保留在当前项目列表中的项目
				const filteredRecentProjects = recentProjects.filter(item => 
					item && item._id && projectIds.includes(item._id)
				);
				
				console.log('[项目列表] 过滤后的快速访问项目数量:', filteredRecentProjects.length);
				
				// 更新到界面
				this.setData({
					quickAccessList: filteredRecentProjects
				});
				
				// 更新项目列表中的标记
				this._updateQuickAccessMarks();
				
				console.log('[项目列表] 快速访问列表加载和标记更新完成');
			} catch (err) {
				console.error('[项目列表] 加载快速访问列表失败', err);
			}
		},
		
		/**
		 * 获取最近访问项目
		 */
		async _getRecentProjects() {
			try {
				// 获取最近访问的项目列表
				const recentProjects = wx.getStorageSync('recentProjects') || [];
				
				// 获取当前项目列表的ID集合
				const projectIds = this.data.dataList.map(item => item._id);
				
				// 过滤快速访问列表，只保留在当前项目列表中的项目
				const filteredRecentProjects = recentProjects.filter(item => 
					// 确保项目有有效ID并且在当前项目列表中
					item && item._id && projectIds.includes(item._id)
				);
				
				// 更新到界面
				this.setData({
					quickAccessList: filteredRecentProjects
				});
				
				// 将dataList映射到filteredProjects，确保显示
				const dataList = this.data.dataList || [];
				plmProjectStore.projects = dataList;
				plmProjectStore.filteredProjects = dataList;
				plmProjectStore.projectCount = dataList.length;
				
				// 更新项目列表中的标记
				this._updateQuickAccessMarks();
				
				return filteredRecentProjects;
			} catch (error) {
				console.error('获取最近访问项目失败:', error);
				return [];
			}
		},
		
		/**
		 * 更新项目列表中的快速访问标记
		 */
		_updateQuickAccessMarks: function() {
			// 获取所有快速访问IDs
			const quickAccessIds = this._getQuickAccessIds();
			console.log('[项目列表] 快速访问ID列表:', quickAccessIds);
			
			if (!this.data.dataList || this.data.dataList.length === 0) {
				console.log('[项目列表] 项目列表为空，无需更新快速访问标记');
				return;
			}
			
			// 更新dataList中的标记
			const dataList = this.data.dataList.map(item => {
				const isInQuickAccess = quickAccessIds.includes(item._id);
				console.log(`[项目列表] 项目${item._id}是否在快速访问中:`, isInQuickAccess);
				item.isInQuickAccess = isInQuickAccess;
				return item;
			});
			
			// 更新filteredProjects中的标记（因为视图是基于filteredProjects渲染的）
			const filteredProjects = this.data.filteredProjects.map(item => {
				item.isInQuickAccess = quickAccessIds.includes(item._id);
				return item;
			});
			
			// 使用新数组引用触发渲染
			this.setData({
				dataList: [...dataList],
				filteredProjects: [...filteredProjects]
			});
			
			console.log('[项目列表] 快速访问标记已更新，标记数量:', quickAccessIds.length);
		},
		
		/**
		 * 点击搜索框
		 */
		bindSearchFocus: function(e) {
			this.setData({
				isFilterOpen: false
			});
		},
		
		/**
		 * 搜索输入
		 */
		bindSearchInput: function(e) {
			// 废弃，使用 onInputChange 替代
		},
		
		/**
		 * 搜索提交
		 */
		bindSearchTap: function(e) {
			// 废弃，使用 onSearchConfirm 替代
		},
		
		/**
		 * 搜索清空
		 */
		bindSearchClearTap: function(e) {
			// 废弃，使用 clearSearch 替代
		},
		
		/**
		 * 打开/关闭筛选
		 */
		onFilterTap: function(e) {
			this.setData({
				isFilterOpen: !this.data.isFilterOpen
			});
		},
		
		/**
		 * 筛选完成 
		 */
		bindFilterConfirmTap: function(e) {
			this.setData({
				page: 1,
				isFilterOpen: false
			});
			this._forceRefreshList();
		},
		
		/**
		 * 筛选变更
		 */
		bindFilterCmpt: function(e) {
			this.setData({
				[e.currentTarget.dataset.field]: e.detail
			});
		},
		
		/**
		 * 项目类型变更
		 */
		bindCateChange: function(e) {
			this.setData({
				cate: e.detail.value
			});
		},
		
		/**
		 * 状态变更
		 */
		bindStatusChange: function(e) {
			this.setData({
				status: e.detail.value
			});
		},
		
		/**
		 * 研发负责人变更
		 */
		bindDevManagerChange: function(e) {
			this.setData({
				devManager: e.detail.value
			});
		},
		
		/**
		 * 业务负责人变更
		 */
		bindBizManagerChange: function(e) {
			this.setData({
				bizManager: e.detail.value
			});
		},
		
		/**
		 * 排序变更
		 */
		bindSortTap: function(e) {
			const sortType = e.currentTarget.dataset.type;
			const sortVal = e.currentTarget.dataset.val;
			
			// 重复点击取消排序
			if (this.data.sortType === sortType && this.data.sortVal === sortVal) {
				this.setData({
					sortType: '',
					sortVal: ''
				});
			} else {
				this.setData({
					sortType,
					sortVal
				});
			}
			
			this.setData({
				page: 1
			});
			
			this._forceRefreshList();
		},
		
		/**
		 * 点击项目
		 */
		bindProjectTap: function(e) {
			const id = e.currentTarget.dataset.id;
			
			// 保存到最近访问
			this._saveRecentProject(id);
			
			wx.navigateTo({
				url: `/projects/plm/pages/project/detail/project_detail?id=${id}`
			});
		},
		
		/**
		 * 新建项目
		 */
		bindAddTap: function(e) {
			wx.navigateTo({
				url: `/projects/plm/pages/project/edit/project_edit`
			});
		},
		
		/**
		 * 保存最近访问项目
		 */
		_saveRecentProject: function(id) {
			try {
				// 从当前列表中查找项目
				const project = this.data.dataList.find(item => item._id === id);
				if (!project) return;
				
				// 获取已有的最近项目列表
				let recentProjects = wx.getStorageSync('recentProjects') || [];
				
				// 删除已存在的相同项目
				recentProjects = recentProjects.filter(item => item._id !== id);
				
				// 添加到首位
				recentProjects.unshift(project);
				
				// 限制最大数量
				if (recentProjects.length > 10) {
					recentProjects = recentProjects.slice(0, 10);
				}
				
				// 保存到缓存
				wx.setStorageSync('recentProjects', recentProjects);
			} catch (err) {
				console.error('保存最近项目失败', err);
			}
		},
		
		/**
		 * 下拉刷新
		 */
		onPullDownRefresh() {
			// 传入true以强制从云端获取数据
			this._forceRefreshList(true);
			wx.stopPullDownRefresh();
		},
		
		/**
		 * 上拉加载更多
		 */
		onReachBottom: function() {
			if (this.data.pagination && this.data.pagination.hasMore && !this.data.loading) {
				const pagination = this.data.pagination;
				pagination.page += 1;
				this.setData({
					pagination: pagination
				});
				this.loadProjects();
			}
		},

		/**
		 * 初始加载数据
		 */
		_loadInitialData: function() {
			this.setData({ isLoadingPage: true });
			
			// 从Store获取数据
			this.loadProjects(true).then(() => {
				this.setData({ 
					isLoadingPage: false,
					dataList: this.data.projects 
				});
			}).catch(err => {
				this.setData({ isLoadingPage: false });
				PageHelper.showModalErr('加载失败: ' + err.message);
			});
		},
		
		/**
		 * 监听Store变化
		 */
		storeChange: function() {
			// 仅当projects变化时更新dataList
			if (this.data.projects !== this.data.dataList) {
				this.setData({ 
					dataList: this.data.projects,
					noMore: this.data.projects.length >= this.data.pagination.total
				});
			}
		},
		
		/**
		 * 搜索项目
		 */
		onSearch: function(e) {
			const search = e.detail.value || '';
			this.setData({ search });
			
			// 使用try-catch包装MobX调用
			try {
				this.setFilter({ search });
			} catch (err) {
				errorHelper.logError('搜索筛选', err);
			}
			this._loadInitialData();
		},
		
		/**
		 * 清除搜索
		 */
		onClearSearch: function() {
			this.setData({ search: '' });
			
			// 使用try-catch包装MobX调用
			try {
				this.setFilter({ search: '' });
			} catch (err) {
				errorHelper.logError('清除搜索', err);
			}
			this._loadInitialData();
		},
		
		/**
		 * 状态筛选变更
		 */
		onStatusChange: function(e) {
			const status = e.currentTarget.dataset.value;
			this.setData({ selectedStatus: status });
			
			// 使用try-catch包装MobX调用
			try {
				this.setFilter({ status });
			} catch (err) {
				errorHelper.logError('状态筛选', err);
			}
			this._loadInitialData();
		},
		
		/**
		 * 排序方式变更
		 */
		onSortChange: function(e) {
			const sortType = e.currentTarget.dataset.value;
			this.setData({ selectedSort: sortType });
			
			// 使用try-catch包装MobX调用
			try {
				this.setFilter({ sortType });
			} catch (err) {
				errorHelper.logError('排序筛选', err);
			}
			this._loadInitialData();
		},
		
		/**
		 * 加载更多项目
		 */
		_loadMoreProjects: async function() {
			// 已经在加载中或已全部加载完成，则不继续加载
			if (this.data.isLoading || this.data.isAllLoaded) return;
			
			try {
				this.setData({ isLoading: true });
				
				// 使用MobX的loadMoreProjects加载更多
				await this.loadMoreProjects();
				
				// 更新组件数据
				this.setData({
					dataList: this.data.projects,
					pagination: this.data.pagination,
					isAllLoaded: !this.data.pagination.hasMore,
					isLoading: false
				});
			} catch (err) {
				// 使用错误助手记录错误
				errorHelper.logError('项目列表加载更多', err);
				
				this.setData({ isLoading: false });
				
				// 使用错误助手处理错误
				if (err.message && err.message.includes('[mobx]')) {
					// 处理MobX错误
					errorHelper.showError(errorHelper.handleMobXError(err));
				} else {
					// 处理其他错误
					errorHelper.showError('加载更多失败');
				}
			}
		},
		
		/**
		 * 页面销毁
		 */
		onUnload: function() {
			// 销毁Store绑定
			if (this.storeBindings) {
				try {
					this.storeBindings.destroyStoreBindings();
					console.log('[项目列表页] MobX绑定已清理');
				} catch (err) {
					console.error('[项目列表页] 清理MobX绑定失败', err);
				}
			}
		},
		
		/**
		 * 搜索确认提交
		 */
		onSearchConfirm: function(e) {
			this.setData({
				search: e.detail.value,
				page: 1
			});
			this._forceRefreshList();
		},
		
		/**
		 * 搜索输入变化
		 */
		onInputChange: function(e) {
			this.setData({
				search: e.detail.value
			});
		},
		
		/**
		 * 清除搜索
		 */
		clearSearch: function() {
			this.setData({
				search: '',
				page: 1
			});
			this._forceRefreshList();
		},
		
		/**
		 * 项目类型变更
		 */
		onCateChange: function(e) {
			this.setData({
				cate: e.detail.value
			});
		},
		
		/**
		 * 研发负责人变更
		 */
		onDevManagerChange: function(e) {
			this.setData({
				devManager: e.detail.value
			});
		},
		
		/**
		 * 业务负责人变更
		 */
		onBizManagerChange: function(e) {
			this.setData({
				bizManager: e.detail.value
			});
		},
		
		/**
		 * 项目状态变更
		 */
		onStatusChange: function(e) {
			this.setData({
				status: e.detail.value
			});
		},
		
		/**
		 * 排序方式变更
		 */
		onSortChange: function(e) {
			const sortType = e.currentTarget.dataset.type;
			this.setData({
				sortType: sortType,
				page: 1
			});
			this._forceRefreshList();
		},
		
		/**
		 * 点击项目项
		 */
		onItemTap: function(e) {
			const id = e.currentTarget.dataset.id;
			
			// 保存到最近访问
			this._saveRecentProject(id);
			
			wx.navigateTo({
				url: `/projects/plm/pages/project/detail/project_detail?id=${id}`
			});
		},
		
		/**
		 * 展开/收起项目详情
		 */
		toggleExpand: function(e) {
			const item = e.currentTarget.dataset.item;
			const index = this.data.dataList.findIndex(i => i.renderKey === item.renderKey);
			
			if (index !== -1) {
				// 更新展开状态
				const key = `dataList[${index}].isExpanded`;
				this.setData({
					[key]: !this.data.dataList[index].isExpanded
				});
				
				// 滚动到元素位置以确保可见
				if (!this.data.dataList[index].isExpanded) {
					// 如果是展开操作，滚动到元素位置
					wx.createSelectorQuery().select(`#project-${item.renderKey}`).boundingClientRect(rect => {
						if (rect && rect.top) {
							wx.pageScrollTo({
								scrollTop: rect.top,
								duration: 300
							});
						}
					}).exec();
				}
			}
		},
		
		/**
		 * 快速访问项目点击
		 */
		onQuickAccessTap: function(e) {
			const id = e.currentTarget.dataset.id;
			wx.navigateTo({
				url: `/projects/plm/pages/project/detail/project_detail?id=${id}`
			});
		},
		
		/**
		 * 长按快速访问项目
		 */
		onQuickAccessLongPress: function(e) {
			const id = e.currentTarget.dataset.id;
			wx.showActionSheet({
				itemList: ['从快速访问中移除'],
				success: res => {
					if (res.tapIndex === 0) {
						// 移除快速访问
						this._removeFromQuickAccess(id);
					}
				}
			});
		},
		
		/**
		 * 检查项目是否在快速访问中
		 */
		_checkIsInQuickAccess: function(id) {
			const recentProjects = wx.getStorageSync('recentProjects') || [];
			return recentProjects.some(item => item._id === id);
		},
		
		/**
		 * 添加到快速访问
		 */
		_addToQuickAccess: function(project) {
			// 获取已有的最近项目列表
			let recentProjects = wx.getStorageSync('recentProjects') || [];
			
			// 删除已存在的相同项目
			recentProjects = recentProjects.filter(item => item._id !== project._id);
			
			// 添加到首位
			recentProjects.unshift(project);
			
			// 限制最大数量
			if (recentProjects.length > 10) {
				recentProjects = recentProjects.slice(0, 10);
			}
			
			// 保存到缓存
			wx.setStorageSync('recentProjects', recentProjects);
			
			// 更新列表
			this.setData({
				quickAccessList: recentProjects
			});
			
			// 更新项目列表中的标记
			this._updateQuickAccessMarks();
			
			// 强制重新渲染
			this.setData({
				filteredProjects: [...this.data.filteredProjects]
			});

			console.log('[项目列表] 项目已添加到快速访问，ID:', project._id);
			
			wx.showToast({
				title: '已添加到快速访问',
				icon: 'success'
			});
		},
		
		/**
		 * 从快速访问中移除
		 */
		_removeFromQuickAccess: function(id) {
			// 获取已有的最近项目列表
			let recentProjects = wx.getStorageSync('recentProjects') || [];
			
			// 删除项目
			recentProjects = recentProjects.filter(item => item._id !== id);
			
			// 保存到缓存
			wx.setStorageSync('recentProjects', recentProjects);
			
			// 更新列表
			this.setData({
				quickAccessList: recentProjects
			});
			
			// 更新项目列表中的标记
			this._updateQuickAccessMarks();
			
			// 强制重新渲染
			this.setData({
				filteredProjects: [...this.data.filteredProjects]
			});

			console.log('[项目列表] 项目已从快速访问中移除，ID:', id);
			
			wx.showToast({
				title: '已从快速访问移除',
				icon: 'success'
			});
		},
		
		/**
		 * 确认删除项目
		 */
		_confirmDeleteProject: function(project) {
			wx.showModal({
				title: '确认删除',
				content: `确定要删除项目"${project.model || '未命名项目'}"吗？此操作不可恢复。`,
				confirmText: '删除',
				confirmColor: '#e64340',
				success: res => {
					if (res.confirm) {
						this._deleteProject(project._id);
					}
				}
			});
		},
		
		/**
		 * 删除项目
		 */
		_deleteProject: async function(id) {
			try {
				wx.showLoading({
					title: '删除中...',
					mask: true
				});
				
				// 调用删除API
				const result = await ProjectBiz.delProject(id);
				
				// 从列表中移除
				let dataList = this.data.dataList.filter(item => item._id !== id);
				this.setData({
					dataList
				});
				
				// 从快速访问中移除
				this._removeFromQuickAccess(id);
				
				wx.hideLoading();
				wx.showToast({
					title: '删除成功',
					icon: 'success'
				});
			} catch (err) {
				wx.hideLoading();
				wx.showModal({
					title: '删除失败',
					content: err.message || '操作失败，请重试',
					showCancel: false
				});
			}
		},
		
		/**
		 * 获取开发状态样式类
		 */
		_getDevelopmentStatusClass: function(developmentStatus) {
			if (!developmentStatus) return 'status-unknown';
			
			// 根据开发状态返回对应的CSS类
			switch (developmentStatus) {
				case '待立项':
					return 'status-pending';
				case '开发中':
				case '设计中':
				case '规划中':
				case '测试中':
				case '验证中':
					return 'status-active';
				case '已完成':
					return 'status-done';
				case '暂停状态':
				case '延期状态':
				case '搁置状态':
					return 'status-paused';
				case '休眠状态':
					return 'status-review';
				default:
					return 'status-unknown';
			}
		},
		
		/**
		 * 检查项目是否在快速访问列表中
		 */
		_isInQuickAccess(projectId) {
			if (!projectId) return false;
			
			// 直接从Storage中获取最新的快速访问列表
			const quickAccessList = wx.getStorageSync('recentProjects') || [];
			
			// 检查项目ID是否在快速访问列表中
			const result = quickAccessList.some(item => item._id === projectId);
			console.log(`[项目列表] 检查项目${projectId}是否在快速访问中:`, result);
			return result;
		},

		/**
		 * 点击云端刷新按钮
		 */
		onCloudRefreshTap: function() {
			// 显示提示
			wx.showToast({
				title: '从云端获取数据',
				icon: 'none',
				duration: 1500
			});
			
			console.log('[项目列表] 用户点击云端刷新按钮');
			
			// 强制从云端刷新，传参true
			this._forceRefreshList(true);
		},

		/**
		 * 从Store加载数据
		 */
		_loadFromStore: function() {
			console.log('[项目列表] 从Store加载数据');
			
			// 直接使用Store中的数据
			if (plmProjectStore.projectList && plmProjectStore.projectList.length > 0) {
				console.log('[项目列表] 使用Store中已有的数据, 数量:', plmProjectStore.projectList.length);
				
				const formattedList = this._formatProjectList(plmProjectStore.projectList);
				this.setData({
					dataList: formattedList,
					filteredProjects: formattedList, // 同步更新filteredProjects
					isLoad: true,
					isLoading: false,
					loading: false
				});
				
				console.log('[项目列表] 从Store加载了 ' + formattedList.length + ' 条项目数据');
				
				// 加载快速访问列表并更新标记
				this._loadQuickAccessList();
			} else {
				console.log('[项目列表] Store中无数据，强制从云端刷新');
				// 如果Store中没有数据，强制从云端获取，确保forceCloud为true
				this._forceRefreshList(true);
			}
		},

		/**
		 * 项目长按处理
		 */
		onItemLongPress: function(e) {
			const item = e.currentTarget.dataset.item;
			
			// 检查用户权限
			const actions = [];
			
			// 基础操作
			actions.push('查看详情');
			
			// 添加/移除快速访问
			const isInQuickAccess = this._isInQuickAccess(item._id);
			actions.push(isInQuickAccess ? '从快速访问中移除' : '添加到快速访问');
			
			// 管理员或创建者可编辑/删除
			if (this.data.isAdmin || (this.data.user && item.PROJECT_USER_ID === this.data.user._id)) {
				actions.push('编辑项目');
				actions.push('删除项目');
			}
			
			wx.showActionSheet({
				itemList: actions,
				success: res => {
					const index = res.tapIndex;
					
					if (actions[index] === '查看详情') {
						wx.navigateTo({
							url: `/projects/plm/pages/project/detail/project_detail?id=${item._id}`
						});
					} else if (actions[index] === '添加到快速访问') {
						this._addToQuickAccess(item);
					} else if (actions[index] === '从快速访问中移除') {
						this._removeFromQuickAccess(item._id);
					} else if (actions[index] === '编辑项目') {
						wx.navigateTo({
							url: `/projects/plm/pages/project/edit/project_edit?id=${item._id}`
						});
					} else if (actions[index] === '删除项目') {
						this._confirmDeleteProject(item);
					}
				}
			});
		},

		onLoad: async function(options) {
			// 网络检测
			const net = await getNetworkStatus();
			if (!net.isConnected) {
				wx.showToast({ title: '当前无网络，请检查连接', icon: 'none' });
			} else if (net.networkType === '2g') {
				wx.showToast({ title: '当前为2G弱网，体验可能受影响', icon: 'none' });
			}
			listenNetworkStatus((res) => {
				if (!res.isConnected) wx.showToast({ title: '网络已断开', icon: 'none' });
				else if (res.networkType === '2g') wx.showToast({ title: '当前为2G弱网', icon: 'none' });
			});
			logEvent('page_load', { page: 'plm_project_list' });
			// ... existing code ...
		},
	}
}); 